第一節：神經網路介紹(1)

• 我們這裡從David Rumelhart、Geoffrey Hinton、Ronald Williams在1986年的研究開始講起（事實上這並非當時的最佳解法）。

• 從電腦剛開始發展的時候，我們就已經開始思考為什麼辨認貓狗對於人類來說這麼容易的事情，讓電腦做起來卻如此困難?

• 這時候生物學家開始踏入了這個領域，如果我們能了解大腦是如何運作的，那是否能模仿其結構進行分類?

第一節：神經網路介紹(2)

• 大腦是神經系統的一部分，而他是由多個神經元互相結合而成的。(下圖為Ramón y Cajal在1905年所畫下的神經細胞樣貌)

– 神經細胞的構造如下，不論是何種神經元皆可分成：接收區、觸發區、傳導區和輸出區。

• 神經細胞傳導訊息的過程是透過電位的變化，在接收區會接收到一個電位改變的訊號，再交給突觸來處理。

• 透過樹突(dendrite)能接收上一個神經元的訊息，而有些會在接收訊息後產生抑制性作用，有些會產生興奮性作用，然後這些訊號再透過神經元整合，之後再透過軸突(axon)將訊號傳導出去。

• 我們根據這樣的生物學知識，開始來用電腦模擬一個簡單的神經元。

第一節：神經網路介紹(3)

• 第一代的人工智慧是1958年由Frank Rosenblatt所發展的感知機(perceptron)，此時還稱不上是神經「網路」，他的結構如下：

• 讓我們用數學語言來描述他：

\[ \begin{align} \mbox{weighted sum} & = w_{0} + w_{1}x_1 + w_{2}x_2 + \dots \\ \hat{y} & = step(\mbox{weighted sum}) \end{align} \]

• 仔細一看，他跟線性回歸實在是很像，差別只是在output經過了一個轉換

第一節：神經網路介紹(4)

• 顯然大腦的構成不是僅僅使用一個神經元，既然邏輯斯回歸的構造與神經元很像，所以我們試著把多個邏輯斯回歸結合在一起吧！

– 讓我們使用MxNet來實現吧！這次我們同樣使用剛剛的IRIS資料集，請到這裡下載這份資料集

– 這次預測的任務比較不一樣，我們使用一部分的資料作為Training set，一部分的資料作為Testing set，而使用花萼(sepal)和花瓣(petal)的長度和寬度來預測鳶尾屬下的三個亞屬：山鳶尾(setosa)、變色鳶尾(versicolor)和維吉尼亞鳶尾(virginica)：

• 需要注意的是，與之前的線性回歸的輸出不同，我們需要把Y.array做編碼：

iris = read.csv('data/iris.csv')

X.array = array(t(as.matrix(iris[,-5])), dim = c(4, 150))
Y.array = array(t(model.matrix(~ -1 + factor(iris[,5]))), dim = c(3, 150))

set.seed(0)
TRAIN.seq = sample(1:150, 100)

TRAIN.X.array = X.array[,TRAIN.seq]
TRAIN.Y.array = Y.array[,TRAIN.seq]
TEST.X.array = X.array[,-TRAIN.seq]
TEST.Y.array = Y.array[,-TRAIN.seq]

第一節：神經網路介紹(5)

• 接著讓我們定義模型架構：

library(mxnet)

data = mx.symbol.Variable(name = 'data')
fc1 = mx.symbol.FullyConnected(data = data, num.hidden = 5, name = 'fc1')
act1 = mx.symbol.Activation(data = fc1, act.type = 'relu', name = 'act1')
fc2 = mx.symbol.FullyConnected(data = act1, num.hidden = 3, name = 'fc2')
out_layer = mx.symbol.SoftmaxOutput(data = fc2, name = 'out_layer')

• 開始訓練，另外我們定義一下模型評估指標：

my.eval.metric.mlogloss <- mx.metric.custom(
  name = "m-logloss", 
  function(real, pred) {
    real1 = as.numeric(as.array(real))
    pred1 = as.numeric(as.array(pred))
    pred1[pred1 <= 1e-6] = 1e-6
    pred1[pred1 >= 1 - 1e-6] = 1 - 1e-6
    return(-mean(real1 * log(pred1), na.rm = TRUE))
  }
)

mx.set.seed(0)

iris_model = mx.model.FeedForward.create(symbol = out_layer,
                                         X = TRAIN.X.array, y = TRAIN.Y.array,
                                         optimizer = "sgd", learning.rate = 0.05, momentum = 0.9,
                                         array.batch.size = 20, num.round = 100,
                                         ctx = mx.cpu(), 
                                         eval.metric = my.eval.metric.mlogloss)

第一節：神經網路介紹(6)

• 再讓我們進行預測吧！

predict_Y = predict(iris_model, TEST.X.array, array.layout = "colmajor")
predict_cat = max.col(t(predict_Y))
real_cat = max.col(t(TEST.Y.array))

confusion_table = table(predict_cat, real_cat)
print(confusion_table)

##            real_cat
## predict_cat  1  2  3
##           1 18  0  0
##           2  0 13  0
##           3  0  2 17

• 覺得準嗎?

第二節：卷積神經網路介紹(1)

• 神經網路最初的構想是利用電腦模擬大腦運作的過程，而前面那個神經網路中的「全連接層」所模擬的是腦細胞傳遞訊息的思考過程。

– 但回到我們的手寫數字分類問題，當我們看到這些手寫數字時，我們一眼就能認出他們了，但從「圖片」到「概念」的過程真的這麼簡單嗎?

• 我們是否有個疑問，當光影映射至視網膜時，這些訊號是如何向後傳遞的?

– 現在我們面對的是視覺問題，看來除了模擬大腦思考運作的過程之外，我們還需要模擬眼睛的作用！

第二節：卷積神經網路介紹(2)

• 1962年時David H. Hubel與Torsten Wiesel共同發表了一篇研究：Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex，這篇研究旨在探討生物視覺系統的運作方式，並獲得了1981年的Nobel prize

– 他們的研究發現，貓咪在受到不同形狀的圖像刺激時，感受野的腦部細胞會產生不同反應

• 這樣的研究給了我們什麼啟示呢?也就是在最開始接觸光影訊號的腦神經細胞，每個細胞會辨認一種特定的簡單特徵，而且這些簡單特徵「無論出現在視野範圍的哪裡」，他們都會被激活。

第二節：卷積神經網路介紹(3)

• 電腦學家受到了上面生物研究的啟發，因此在多層感知器(網路中的全連接層)之前增加了一個構造，叫做「卷積器」(convolution filter)

– 卷積器模擬了感受野最初的細胞，他們負責用來辨認特定特徵，他們的數學模式如下：

• 簡單來說，卷積器透過一個「濾鏡」對圖片進行全局的搜索，而卷積後的新圖片稱為「特徵圖」

– 「特徵圖」的意義是什麼呢?卷積器就像是最初級的視覺細胞，他們專門辨認某一種簡單特徵，那這個「特徵圖」上面數字越大的，就代表那個地方越符合該細胞所負責的特徵。

第二節：卷積神經網路介紹(4)

• 那假定我們有3個卷積器，分別負責「＼」、「╳」、「／」，那將會產生3個特徵圖，分別如下：

• 獲得特徵圖之後，還記得我們為了增加神經網路的數學複雜性，會添加一些非線性函數做轉換，因此卷積神經網路在經過卷積層後的特徵圖會再經過非線性轉換。

• 接著，由於連續卷積的特徵圖造成了訊息的重複，這時候我們經常會使用「池化層」(pooling layer)進行圖片降維，事實上他等同於把圖片的解析度調低，這同時也能節省計算量。

第二節：卷積神經網路介紹(5)

• 接著我們思考一下，連續的堆疊「卷積器」會產生什麼效果?

– 我們想像有一張人的圖片，假定第一個卷積器是辨認眼睛的特徵，第二個卷積器是在辨認鼻子的特徵，第三個卷積器是在辨認耳朵的特徵，第四個卷積器是在辨認手掌的特徵，第五個卷積器是在辨認手臂的特徵

– 第1.2.3張特徵圖中數值越高的地方，就分別代表眼睛、鼻子、耳朵最有可能在的位置，那將這3張特徵圖合在一起看再一次卷積，是否就能辨認出人臉的位置?

– 第4.5張特徵圖中數值越高的地方，就分別代表手掌、手臂最有可能在的位置，那將這2張特徵圖合在一起看再一次卷積，是否就能辨認出手的位置?

– 第4.5張特徵圖對人臉辨識同樣能起到作用，因為人臉不包含手掌、手臂，因此如果有個卷積器想要辨認人臉，他必須對第1.2.3張特徵圖做正向加權，而對第4.5張特徵圖做負向加權

• 所以，我們可以在神經網路中堆疊卷積器，而越淺層的卷積器所辨認的特徵越簡單，越深層的卷積器所辨認的特徵越複雜。

第三節：利用卷積神經網路做手寫數字辨識(1)

• 讓我們一起來實現1989年Yann LeCun所發展的世界上第一個成功的卷積神經網路(Convolutional Neural Networks，CNN)，這個CNN被命名為LeNet。

第三節：利用卷積神經網路做手寫數字辨識(2)

• 讓我們把剛剛MNIST的手寫數字資料讀取近來

– 請在這裡下載MNIST的手寫數字資料，並讓我們了解一下這筆資料的結構

library(data.table)

mnist = fread("data/MNIST.csv", data.table = FALSE)
mnist = data.matrix(mnist)

n.sample = dim(mnist)[1]

X = mnist[,-1]
X = t(X)
dim(X) = c(28, 28, 1, dim(mnist)[1])
for (i in 1:dim(X)[4]) {
  X[,,,i] = t(X[,,,i] )
}

Y = array(t(model.matrix(~ -1 + factor(mnist[,1]))), dim = c(10, n.sample))

• 再看一次隨便一張圖以及他的label吧：

library(OpenImageR)

imageShow(X[,,,25])

Y[,25]

##  [1] 0 0 1 0 0 0 0 0 0 0

第三節：利用卷積神經網路做手寫數字辨識(3)

• 把資料分成Training set以及Testing set：

– 另外，我們需要對X進行標準化(平均值33.4，標準差78.7)，有些人可以嘗試不先標準化的結果，你會發現根本無法訓練！

print(mean(X))

## [1] 33.40891

print(sd(X))

## [1] 78.67774

X = (X - mean(X))/sd(X)

set.seed(0)
Train.sample = sample(1:n.sample, n.sample*0.6, replace = FALSE)

Train.X = X[,,,Train.sample]
dim(Train.X) = c(28, 28, 1, n.sample * 0.6)
Train.Y = Y[,Train.sample]

Test.X = X[,,,-Train.sample]
dim(Test.X) = c(28, 28, 1, n.sample * 0.4)
Test.Y = Y[,-Train.sample]

• 我們先把Training/Test的資料寫出，這樣下次我們就可以比較快的讀進來了：

fwrite(x = data.table(mnist[Train.sample,]),
       file = 'data/train_data.csv',
       col.names = FALSE, row.names = FALSE)

fwrite(x = data.table(mnist[-Train.sample,]),
       file = 'data/test_data.csv',
       col.names = FALSE, row.names = FALSE)

第三節：利用卷積神經網路做手寫數字辨識(4)

• 準備好資料後，讓我們定義模型結構：

# input
data <- mx.symbol.Variable('data')

# first conv
conv1 <- mx.symbol.Convolution(data=data, kernel=c(5,5), num_filter=10, name = 'conv1')
relu1 <- mx.symbol.Activation(data=conv1, act_type="relu")
pool1 <- mx.symbol.Pooling(data=relu1, pool_type="max",
                          kernel=c(2,2), stride=c(2,2))

# second conv
conv2 <- mx.symbol.Convolution(data=pool1, kernel=c(5,5), num_filter=20, name = 'conv2')
relu2 <- mx.symbol.Activation(data=conv2, act_type="relu")
pool2 <- mx.symbol.Pooling(data=relu2, pool_type="max",
                          kernel=c(2,2), stride=c(2,2))

# first fullc
flatten <- mx.symbol.Flatten(data=pool2)
fc1 <- mx.symbol.FullyConnected(data=flatten, num_hidden=150, name = 'fc1')
relu3 <- mx.symbol.Activation(data=fc1, act_type="relu")

# second fullc
fc2 <- mx.symbol.FullyConnected(data=relu3, num_hidden=10, name = 'fc2')

# Softmax
lenet <- mx.symbol.SoftmaxOutput(data = fc2, name = 'lenet')

• 這個網路結構如下：

1. 原始圖片(28x28x1)要先經過10個5x5的「卷積器」(5x5x1x10)處理，將使圖片變成10張「一階特徵圖」(24x24x10)

2. 接著這10張「一階特徵圖」(24x24x10)會經過ReLU，產生10張「轉換後的一階特徵圖」(24x24x10)

3. 接著這10張「轉換後的一階特徵圖」(24x24x10)再經過2x2「池化器」(2x2)處理，將使圖片變成10張「降維後的一階特徵圖」(12x12x10)

– 第二層卷積組合

4. 再將10張「降維後的一階特徵圖」(12x12x10)經過20個5x5的「卷積器」(5x5x10x20)處理，將使圖片變成20張「二階特徵圖」(8x8x20)

5. 接著這20張「二階特徵圖」(8x8x20)會經過ReLU，產生20張「轉換後的二階特徵圖」(8x8x20)

6. 接著這20張「轉換後的二階特徵圖」(8x8x20)再經過2x2「池化器」(2x2)處理，將使圖片變成20張「降維後的二階特徵圖」(4x4x20)

– 全連接層

7. 將「降維後的二階特徵圖」(4x4x20)重新排列，壓製成「一階高級特徵」(320)

8. 讓「一階高級特徵」(320)進入「隱藏層」，輸出「二階高級特徵」(150)

9. 「二階高級特徵」(150)經過ReLU，輸出「轉換後的二階高級特徵」(150)

10. 「轉換後的二階高級特徵」(150)進入「輸出層」，產生「原始輸出」(10)

11. 「原始輸出」(10)經過Softmax函數轉換，判斷圖片是哪個類別

第三節：利用卷積神經網路做手寫數字辨識(5)

• 我們使用剛剛那個模型評估指標(同樣多是多分類任務)並開始訓練(這個要跑一陣子)：

my.eval.metric.mlogloss <- mx.metric.custom(
  name = "m-logloss", 
  function(real, pred) {
    real1 = as.numeric(as.array(real))
    pred1 = as.numeric(as.array(pred))
    pred1[pred1 <= 1e-6] = 1e-6
    pred1[pred1 >= 1 - 1e-6] = 1 - 1e-6
    return(-mean(real1 * log(pred1), na.rm = TRUE))
  }
)

mx.set.seed(0)

lenet_model = mx.model.FeedForward.create(symbol = lenet,
                                          X = Train.X, y = Train.Y,
                                          optimizer = "sgd", learning.rate = 0.05, momentum = 0.9,
                                          array.batch.size = 100, num.round = 20,
                                          ctx = mx.cpu(),
                                          eval.metric = my.eval.metric.mlogloss)

• 看看預測準確度：

predict_Y = predict(lenet_model, Test.X)
predict_cat = max.col(t(predict_Y))
real_cat = max.col(t(Test.Y))

confusion_table = table(predict_cat, real_cat)
cat("Testing accuracy rate =", sum(diag(confusion_table))/sum(confusion_table))

## Testing accuracy rate = 0.9795833

print(confusion_table)

##            real_cat
## predict_cat    1    2    3    4    5    6    7    8    9   10
##          1  1656    1    4    2    3    4   11    0    8    7
##          2     0 1841    6    0    5    0    1    7    5    1
##          3     0    2 1625    4    1    0    1   15    6    0
##          4     0    0    3 1678    0    2    0    3    4    5
##          5     0    1    5    0 1568    0    7    1    3    7
##          6     1    0    2   42    0 1515    2    0    4   12
##          7     1    0    2    0    0   15 1638    0   18    0
##          8     1    3    5    5    5    8    0 1721    1   14
##          9     2    3    4    7    1    3    1    2 1622    3
##          10    2    0    0    4   23    4    0    4    4 1593

• 你是否覺得非常驚訝，準確度居然有98%以上！而這就是卷積神經網路的威力。

第四節：保存模型並讀取新的圖片進行預測(1)

• 儲存/讀取模型的方法跟之前一樣：

#Save model
mx.model.save(lenet_model, "model/lenet", iteration = 0)

#Load model
lenet_model = mx.model.load("model/lenet", iteration = 0)

• 但預測的部分就差很多了，我們首先需要把圖片讀進來。

– 範例圖片可以從這裡下載

library(OpenImageR)

new_digit = readImage('digits/digit.1.jpeg')
imageShow(new_digit)

• 圖片常常讀進來因為是彩色圖，所以我們要先轉黑白圖，再直接進行預測看看，你會發現好像不是很準：

new_digit = rgb_2gray(new_digit)
dim(new_digit) = c(28, 28, 1, 1)

pred_y = predict(lenet_model, new_digit)
print(pred_y)

##              [,1]
##  [1,] 0.004551838
##  [2,] 0.009206435
##  [3,] 0.008242927
##  [4,] 0.014129665
##  [5,] 0.002852110
##  [6,] 0.010479977
##  [7,] 0.007251740
##  [8,] 0.004390656
##  [9,] 0.932146251
## [10,] 0.006748293

第四節：保存模型並讀取新的圖片進行預測(2)

• 關鍵原因其實是因為我們在訓練網路前其實有對圖像做過標準化(平均值33.4，標準差78.7)，並且原來的圖片數值是介於0至255，現在是介於1，所以我們要先進行圖像數值的前處理：

new_digit = new_digit * 255
new_digit = (new_digit - 33.4) / 78.7

dim(new_digit) = c(28, 28, 1, 1)

pred_y = predict(lenet_model, new_digit)
print(round(pred_y, 3))

##       [,1]
##  [1,]    0
##  [2,]    0
##  [3,]    0
##  [4,]    0
##  [5,]    0
##  [6,]    0
##  [7,]    0
##  [8,]    0
##  [9,]    1
## [10,]    0

• 把整個過程打包成一個函數並試試其他圖片吧：

preprocessing = function (img) {
  
  img = rgb_2gray(img)
  img = img * 255
  img = (img - 33.4) / 78.7
  
  dim(img) = c(28, 28, 1, 1)
  
  img
  
}

new_digit = readImage('digits/digit.2.jpeg')
imageShow(new_digit)

new_digit = preprocessing(new_digit)
pred_y = predict(lenet_model, new_digit)
print(round(pred_y, 3))

##       [,1]
##  [1,]    0
##  [2,]    1
##  [3,]    0
##  [4,]    0
##  [5,]    0
##  [6,]    0
##  [7,]    0
##  [8,]    0
##  [9,]    0
## [10,]    0

小結

• 你已經學會了圖像識別的核心技術了，也成功的訓練出一個自己的卷積神經網路，並且能夠把模型留下來留待未來的情形使用了！

– 但你要注意你對圖像做過的所有前處理，在預測的時候全部都要重複一次！

• 下一節課的重點就在於把這項技能運用到更複雜的真實世界圖片上，並且我們試著把這個程式寫成一個圖形化介面，讓你能把你的工作分享給其他不會寫程式的人使用！